home *** CD-ROM | disk | FTP | other *** search
/ Over 1,000 Windows 95 Programs / Over 1000 Windows 95 Programs (Microforum) (Disc 1).iso / 0362 / bcsdk.zip / SAMPLE.C < prev    next >
C/C++ Source or Header  |  1995-04-01  |  4KB  |  195 lines
  1. /*
  2.     BarClock(tm)
  3.  
  4.     Keyword Extension Sample
  5.  
  6.     Copyright (c) 1994  Patrick Breen
  7.     All rights reserved.
  8.  
  9.     Contact Information:
  10.  
  11.         Atomic Dog Software
  12.         PO Box 523
  13.         Medford, MA 02155
  14.  
  15.         Phone (617) 396-2673
  16.         Fax   (617) 396-5761
  17.  
  18.         Internet:            pbreen@world.std.com
  19.         CompuServe:         70312,743
  20.         America Online:     PBreen
  21. */
  22.  
  23. #include "bchook.h"
  24. #include <string.h>
  25.  
  26. // Handle to the DLL instance from Libinit.asm
  27. HANDLE LIBINST;
  28.  
  29. // Simple array of text strings we recognize
  30. static char FAR *pKeys[] = { "patrick", "breen", "" };
  31.  
  32. static HMENU hMenu = 0;
  33.  
  34.  
  35. // Standard library initialization
  36. int FAR PASCAL LibMain(HINSTANCE hInstance, WORD a, WORD b, LPSTR c)
  37. {
  38.     LIBINST = hInstance;
  39.     return 1;
  40. }
  41.  
  42. // Standard library exit
  43. int FAR PASCAL WEP(int a)
  44. {
  45.     return TRUE;
  46. }
  47.  
  48. // Standard version number return
  49. DWORD FAR _export BCHookVersion(DWORD FAR *pSig)
  50. {
  51.     (*pSig) = 0x474F4441L;        // 'ADOG' (in reverse)
  52.     return HOOKVERSION;
  53. }
  54.  
  55. // We will recognize a two keywords [patrick] and
  56. // [breen] - when the text "breen" comes in, we will
  57. // pass back the unique identifier of 1 and
  58. // for "patrick", we will pass back 2 - if neither
  59. // matches, we pass back IDK_NONE
  60. BYTE FAR _export IsKeyword(LPSTR pTxt, short FAR *pLen)
  61. {
  62.     char FAR *pKey;
  63.     short len;
  64.     BYTE id;
  65.  
  66.     // Loop over the keywords we understand
  67.     for (id = 1, pKey = pKeys[0]; *pKey; pKey = pKeys[id++]) {
  68.  
  69.         // Get the length of the current key
  70.         len = strlen(pKey);
  71.  
  72.         // If this one matches
  73.         if (!strncmp(pTxt, pKey, len)) {
  74.  
  75.             // Set the length and return
  76.             // a unique identifier for it
  77.             *pLen = len;
  78.             return id;
  79.         }
  80.     }
  81.  
  82.     // No match
  83.     return IDK_NONE;
  84. }
  85.  
  86. // We expand the keywords here - in this example we
  87. // map [patrick] to output Breen and map [breen] to
  88. // output Patrick.
  89. short FAR _export ExpandKeyword(BYTE id, LPSTR pOutbuf)
  90. {
  91.     short len = 0;
  92.  
  93.     switch (id) {
  94.  
  95.         // Handle 'patrick'
  96.         case 1:
  97.             len = wsprintf(pOutbuf, "%s", "Breen");
  98.             break;
  99.  
  100.         // Handle 'breen'
  101.         case 2:
  102.             len = wsprintf(pOutbuf, "%s", "Patrick");
  103.             break;
  104.     }
  105.  
  106.     // Return the number of bytes
  107.     // added to the output buffer
  108.     return len;
  109. }
  110.  
  111. // Return the text that corresponds to the
  112. // keywords that we recognize
  113. short FAR _export KeywordText(BYTE id, LPSTR pOutbuf)
  114. {
  115.     // Copy the keyword text into the output
  116.     // buffer and return the length - for this
  117.     // sample, we only need to index into the
  118.     // key array that is defined above
  119.     return wsprintf(pOutbuf, "%s", pKeys[id - 1]);
  120. }
  121.  
  122. // Return the number of buttons we support
  123. BYTE FAR _export BCBtnCount(void)
  124. {
  125.     // We support 2 buttons
  126.     return 2;
  127. }
  128.  
  129. // Return the label for the button
  130. void FAR _export BCBtnLabel(BYTE btnId, LPSTR pLabelBuf)
  131. {
  132.     // Copy appropriate label into buffer
  133.     if (btnId == 0) lstrcpy(pLabelBuf, "This is a click button");
  134.     if (btnId == 1) lstrcpy(pLabelBuf, "This is a menu button");
  135.     return;
  136. }
  137.  
  138.  
  139. // Return a menu that should be displayed
  140. // when the specified button is clicked -
  141. // this function is called just prior to
  142. // display of the menu
  143. HMENU FAR _export BCBtnMenu(BYTE btnId)
  144. {
  145.     if (btnId == 1) {
  146.  
  147.         // Create a popup menu (if a resource
  148.         // menu is used, be sure to call the
  149.         // function GetSubMenu to get the
  150.         // proper popup menu handle to display
  151.         //
  152.         // e.g.
  153.         //
  154.         // hMenu = LoadMenu(hInstance, MAKEINTRESOURCE(id));
  155.         // hPopup = GetSubMenu(hMenu, 0);
  156.  
  157.         // We will create our menu
  158.           hMenu = CreatePopupMenu();
  159.  
  160.         // Add to the menu
  161.         AppendMenu(hMenu, 0, 1, "Item 1");
  162.         AppendMenu(hMenu, 0, 2, "Item 2");
  163.         AppendMenu(hMenu, 0, 3, "Item 3");
  164.     }
  165.  
  166.     return hMenu;
  167. }
  168.  
  169.  
  170. // Handle a button click
  171. void FAR _export BCBtnClick(BYTE btnId)
  172. {
  173.     MessageBox((HWND) 0, "We were clicked!", "BarClock Hook", MB_OK);
  174.     return;
  175. }
  176.  
  177.  
  178. // Handle a menu selection
  179. void FAR _export BCBtnMenuSelect(BYTE btnId, short itemId)
  180. {
  181.     // If an item was selected
  182.     if (itemId) {
  183.  
  184.         MessageBox((HWND) 0, "Menu item selected!", "BarClock Hook", MB_OK);
  185.     }
  186.  
  187.     // Clean up menu
  188.     DestroyMenu(hMenu);
  189.     hMenu = 0;
  190.  
  191.     return;
  192. }
  193.  
  194.  
  195.